snippet     wi
abbr        with ...;...
options     head
	with ${1};${2}

snippet     pac
abbr        package {NAME} is {...} end
options     head
	package ${1} is
                ${0}
        end $1;


snippet     pacy
abbr        package body {NAME} is {...} end
options     head
	package body ${1} is
                ${0}
	end $1;

snippet     ent
abbr        entry {...} when
options     head
	entry ${1}(${2}) when ${3} is
	begin
		${0}
	end $1;

snippet     task
abbr        task
options     head
	task ${1} is
		entry ${0}
	end $1;

snippet     task
abbr        task body
options     head
	task body ${1} is
		${2}
	begin
		${0}
	end $1;

snippet     ac
abbr        accept
options     head
	accept ${1}(${2}) do
		${0}
	end $1;

snippet     pro
abbr        protected type
options     head
	protected type ${1}(${2}) is
		${0}
	end $1;

snippet     pro
abbr        protected body
options     head
	protected body ${1} is
		${2}
	begin
		${0}
	end $1;

snippet     ge
abbr        generic type
options     head
	generic
		type ${1} is ${2};${0}

snippet     t
abbr        type
options     head
	type ${1} is ${2};${0}

snippet     ty
abbr        type with default value
options     head
	type ${1} is ${2}
		with Default_Value => ${3};${0}

snippet     subt
abbr        subtype
options     head
	subtype ${1} is ${2};${0}

snippet     de
abbr        declare block
options     head
	declare
		${1}
	begin
		${0}
	end;

snippet     dec
abbr        declare named block
options     head
	${1}:
	declare
		${2}
	begin
		${0}
	end $1;

snippet     ife
abbr        if expression
options     head
	if ${1} then ${2} else ${0}

snippet     case
abbr        case expression
options     head
	case ${1} is
		when ${2} => ${3},${0}

snippet     for
abbr        for all
options     head
	for all ${1} ${2:in} ${3} => ${0}

snippet     for
abbr        for some
options     head
	for some ${1} ${2:in} ${3} => ${0}

snippet     i
abbr        if
options     head
	if ${1} then
		${0}
	end if;

snippet     if
abbr        if ... else
options     head
	if ${1} then
		${2}
	else
		${0}
	end if;

snippet     e
abbr        else
options     head
	else
		${0}

snippet     ei
abbr        elsif
options     head
	elsif ${1} then
		${0}

snippet     w
abbr        while
options     head
	while ${1} loop
		${0}
	end loop;

snippet     nw
abbr        named while
options     head
	${1}:
	while ${2} loop
		${0}
	end loop $1;

snippet     fo
abbr        for
options     head
	for ${1:I} in ${2} loop
		${0}
	end loop;

snippet     for
abbr        for each
options     head
	for ${1} of ${2} loop
		${0}
	end loop;

snippet     nfo
abbr        named for
options     head
	${1}:
	for ${2:I} in ${3} loop
		${0}
	end loop $1;

snippet     nfor
abbr        named for each
options     head
	${1}:
	for ${2} of ${3} loop
		${0}
	end loop $1;

snippet     pro
abbr        procedure
options     head
	procedure ${1}(${2}) is
		${3}
	begin
		${0}
	end $1;

snippet     proc
abbr        procedure declaration
options     head
	procedure ${1};${0}

snippet     fu
abbr        function
options     head
	function ${1}(${2}) return ${3} is
		${4}
	begin
		${0}
	end $1;

snippet     fun
abbr        expression function
options     head
	function ${1} return ${2} is
		(${3});${0}

snippet     fun
abbr        function declaration
options     head
	function ${1} return ${2};${0}

snippet     re
abbr        extended return
options     head
	return ${1} do
		${0}
	end return;

snippet     re
abbr        record
options     head
	record
		${0}
	end record;

snippet     cas
abbr        case
options     head
	case ${1} is
		when ${2} => ${3};${0}
	end case;

snippet     wh
abbr        when
options     head
	when ${1} => ${2};${0}

snippet     whe
abbr        when others
options     head
	when others => ${1};${0}

snippet     l
abbr        loop
options     head
	loop
		${0}
	end loop;

snippet     nl
abbr        named loop
options     head
	${1}:
	loop
		${0}
	end loop $1;

snippet     e
abbr        exit when
options     head
	exit when ${1};
        ${0}

snippet     pu
abbr        Ada.Text_IO.Put
options     head
	Ada.Text_IO.Put(${1});
        ${0}

snippet     put
abbr        Ada.Text_IO.Put_Line
options     head
	Ada.Text_IO.Put_Line(${1});
        ${0}

snippet     ge
abbr        Ada.Text_IO.Get
options     head
	Ada.Text_IO.Get(${1});
        ${0}

snippet     get
abbr        Ada.Text_IO.Get_Line
options     head
	Ada.Text_IO.Get_Line(${1});
        ${0}

snippet     newlin
abbr        Ada.Text_IO.New_Line
options     head
	Ada.Text_IO.New_Line(${1:1});
        ${0}

